/**
 * @description  : 字典公共文件
 * @descriptionDetail : 字典公共文件
 * @copyright    : 浙江烟草
 * @author       : mc
 * @create       : 2022-10-04 11:23:27
 */
import commonService from '@/service/common/common.service';
import store from '../store';
const DIC_ALL_DATA = 'allDicData'; // 所有数据保存，用于其他
const DIC_DICT_MAP = 'allDicMap'; //  key，value存储
// 某个数据字典的key
const DIC_KEYS = {
	SPECIAL: 'L_SPECIAL_GROUP_TYPE', // 群体类型
	FORMAT: 'L_BIZ_FORMAT', // 零售业态
	OWNERSHIP: 'L_GROUND_OWNERSHIP',
	AUDIT_DECIDE: 'M_RE_FIELD_AUDIT_DECIDE',
	FACT: 'L_FACT_STOP',
	AREA_TYPE: 'L_AREA_TYPE',
	BIZ_FORMAT: 'L_BIZ_FORMAT',
	REASON: 'L_UNLICENSE_REASON', // 未办证原因 (无证户采集)
	LICSTATUS: 'RETAILER_UNLICENSE_LICSTATUS', // 经营状态 (无证户采集)
	RETAILER_AREA_TYPE: 'RETAILER_AREA_TYPE', // 区域类型 (无证户采集)
	RETAILER_BUSI_TYPE: 'RETAILER_BUSI_TYPE', // 商圈 (无证户采集)
	RETAILER_ENV_TYPE: 'L_ENV_TYPE', // 地理环境 (无证户采集)
	RETAILER_GROUND_OWNERSHIP: 'L_GROUND_OWNERSHIP', // 经营场地权属 (无证户采集)
	BSC_GENDDER: 'S_BSC_GENDDER', // 性别 (无证户采集)
	RETAILER_CRED_TYPE: 'RETAILER_CRED_TYPE', // 证件类型 (无证户采集)
	UNLICENSE_STATUS: 'UNLICENSE_STATUS', // 经营状态
	NATION_LIST: 'S_BSC_NATION', // 民族
  SAMPLE_STYLE: 'C_SAMPLE_STYLE', // 抽样方法
  BSC_SERVICE_TYPE:'S_BSC_SERVICE_TYPE',// 送达方式
	UNLICENSE_RELATION_PERSON: 'L_UNLICENSE_RELATION_PERSON', // 无证户-从业人员与经营者关系
	RETAILER_RELATIONSHIP: 'RETAILER_RELATIONSHIP',
	REPORT_STYLE: 'C_REPORT_STYLE', // 举报形式
	IDCARD_TYPE: 'S_BSC_IDCARD_TYPE', // 证件类型
	TOBACCO_GOODS_TYPE: 'C_TOBACCO_GOODS_TYPE', // 涉及烟草专卖物品
	CASE_SOURCE: 'C_CASE_SOURCE', // 来源类型
	EVID_TYPE: 'C_EVID_TYPE', // 证据类型
	GET_NODE: 'C_GET_NODE', // 查获环节
	C_GENDER_LIST: 'C_GENDER_LIST', // 性别（检查勘验笔录）
	C_DENS_TYPE: 'C_DENS_TYPE', // 窝点类型
	C_DENS_SUBTYPE: 'C_DENS_SUBTYPE', // 窝点小类
	S_SYS_YES_NO: 'S_SYS_YES_NO', // 是否启用
	S_SYS_IS_ACTIVE: 'S_SYS_IS_ACTIVE', // 快递状态
	CLUE_SOURCE: 'C_CLUE_SOURCE', // 线索来源
	LOGISTICS_TYPE: 'LOGISTICS_TYPE', // 运输类型
	C_LOGISTICS_TYPE: 'C_LOGISTICS_TYPE', // 运输类型
	C_TRANSPORT_ADDR: 'C_TRANSPORT_ADDR', // 运输案件案发地
	K_TRANSPORT_STYLE: 'K_TRANSPORT_STYLE', // 运输方式
	C_DIC_CAR_TYPE: 'C_DIC_CAR_TYPE', // 涉案关系
	C_CAR_STYLE: 'C_CAR_STYLE', // 车型
	C_CAR_COLOR: 'C_CAR_COLOR', // 车辆颜色
	K_TRANSPORT_TOOL: 'K_TRANSPORT_TOOL', // 水路运输工具
	K_TRANSPORT_WAY: 'K_TRANSPORT_WAY', // 水轮运输方式
	L_PIC_CID_TYPE: 'L_BSC_IDCARD_TYPE', // 证件类型
	L_GENDER_LIST: 'L_GENDER_LIST', // 性别
	ROLE_OF_CASE: 'C_ROLE_OF_CASE', // 涉案关系
	C_PARTYINFO_TYPE: 'C_PARTYINFO_TYPE', //  参与角色
	INFO_TYPE: 'C_INFO_TYPE', //
	GOODS_PROP_SUBTYPE: 'C_GOODS_PROP_SUBTYPE', // 物品性质
	CIGA: 'C_CIGA', // 烟类型
	SAMPLE_SOURCE: 'SAMPLE_SOURCE', // 当事人类型
	GET_SAMPLE_TYPE: 'GET_SAMPLE_TYPE', // 来样方式
	REPORT_OBTAIN_TYPE: 'REPORT_OBTAIN_TYPE', // 报告获取方式
	Q_SAMPLE_CHANNEL: 'Q_SAMPLE_CHANNEL', // 查获渠道
	CASE_PROPERTY: 'CASE_PROPERTY', // 案件性质
	SAMPLE_TYPE: 'SAMPLE_TYPE', // 样品状态
	PACK_TYPE: 'PACK_TYPE', // 包装形式
	C_PART_LINK: 'C_PART_LINK', // 细分环节
	C_FEEDBACK_ORG_TYPE: 'C_FEEDBACK_ORG_TYPE', // 单位类型
	RETAILER_ELIC_STATUS: 'RETAILER_ELIC_STATUS', // 经营状态
	SALES_MODE: 'SALES_MODE', // 销售方式
	BUSINESS_MODE: 'BUSINESS_MODE', // 经营方式
	STORE_TYPE: 'STORE_TYPE', // 门店类型
	I_FIELD_CHECK_SOURCE: 'I_FIELD_CHECK_SOURCE', // 任务类型
	M_SIMPLING_CIG_TYPE: 'M_SIMPLING_CIG_TYPE', // 质检结果
	L_SUBJECT_TYPE: 'L_SUBJECT_TYPE', // 持证类型
	GOODS_PROP_TYPE: 'C_GOODS_PROP_TYPE',
	GOODS_TYPE: 'C_GOODS_TYPE',
	S_CIG_GOODS_TYPE: 'S_CIG_GOODS_TYPE',
	L_PERSON_TYPE: 'L_PERSON_TYPE', // 人员类型
	L_UNLICENSE_LICSTATUS: "L_UNLICENSE_LICSTATUS", // 经营状态
	L_WARN_TYPE: 'L_WARN_TYPE', // 预警类型
	RETAILER_LIC_STATUS: 'RETAILER_LIC_STATUS', // 许可证状态
	SOURCE_TYPE: 'K_SOURCE_TYPE',
	L_IMPORT_LIC_CONTENT: "L_IMPORT_LIC_CONTENT", // 重大许可
	L_LAYOUT_POLICY_TYPE: "L_LAYOUT_POLICY_TYPE", // 照顾政策
	C_TRANSPORT_STYLE: 'C_TRANSPORT_STYLE',
	L_EDU_LEVEL: 'L_EDU_LEVEL', // 文化程度
	T_PERSON_MARITAL_STATUS: 'T_PERSON_MARITAL_STATUS', // 婚姻状态
	C_INDUSTRY_CHAIN_FAKE: 'C_INDUSTRY_CHAIN_FAKE', // 产业链涉假环节
	M_DAY_PLAN_TERMINATION_REASON: 'M_DAY_PLAN_TERMINATION_REASON', // 终止原因
	M_DAY_PLAN_TYPE: 'M_DAY_PLAN_TYPE', // 计划类型
	M_TASK_SOURCE: "M_TASK_SOURCE", // 任务来源
	M_TASK_TYPE: "M_TASK_TYPE", // 任务类型
	M_DAY_PLAN_APPROVAL_STATUS: 'M_DAY_PLAN_APPROVAL_STATUS', // 日计划终止审批状态
	M_TASK_SUBJECT: 'M_TASK_SUBJECT', // 任务主体
	M_CHECK_RESULT: "M_CHECK_RESULT", // 检查结果
	L_LIC_STATUS: "L_LIC_STATUS", // 新许可证状态
	SYS_SUBSYS: "S_SYS_SUBSYS", // 子系統
	T_NOTICE_PUBLISH_STATUS: "T_NOTICE_PUBLISH_STATUS", // 发布状态
	T_NOTICE_PUBLISH_RANGE: "T_NOTICE_PUBLISH_RANGE", // 发布范围
	T_NOTICE_PUBLISH_TYPE: "T_NOTICE_PUBLISH_TYPE", // 发布类型
	L_UNLICENSE_SOURCE: 'L_UNLICENSE_SOURCE', // 无证户来源
	L_RELATION_TYPE: 'L_RELATION_TYPE', // 无证户关联关系
	L_RELATIONSHIP: 'L_RELATIONSHIP', // 与经营户关系
	C_EVID_PHOTO_TYPE: 'C_EVID_PHOTO_TYPE', // 证据类型
	L_BUSI_TYPE: 'L_BUSI_TYPE', // 商圈情况
	L_HIDDEN_CHAIN: 'L_HIDDEN_CHAIN', // 隐性连锁店
	M_CHECK_MODE: 'M_CHECK_MODE', // 检查模式
	M_SAMPLING_CHECK_STATUS: 'M_SAMPLING_CHECK_STATUS', // 考核检查状态
	C_STORE_CHECK_TYPE: 'C_STORE_CHECK_TYPE', // 盘库类型
	T_SYS_IS_ACTIVE: 'T_SYS_IS_ACTIVE', // 状态
	I_HANDLE_TYPE: 'I_HANDLE_TYPE', // 异常文书-调查方式
	I_EXC_SOURCE: 'I_EXC_SOURCE', // 异常文书-线索来源
	I_WR_BUS_TYPE: 'I_WR_BUS_TYPE', // 异常文书-监管对象
	I_EXC_LINK: 'I_EXC_LINK', // 异常文书-问题环节
	I_WARN_CONC_STATUS: 'I_WARN_CONC_STATUS', // 异常文书-调查结论与结果定性
	I_WR_BUS_HIDDEN_TYPE: 'I_WR_BUS_HIDDEN_TYPE', // 异常文书-隐患
	I_WR_BUS_PROBLEM_TYPE: 'I_WR_BUS_PROBLEM_TYPE', // 异常文书-问题
	I_EXC_DEAL_TYPE: 'I_EXC_DEAL_TYPE', // 异常文书-问题隐患处理
	I_STEERING_ADVISE_TYPE: 'I_STEERING_ADVISE_TYPE', // 监督建议书-建议类型
	I_CHECK_CASETYPE: 'I_CHECK_CASETYPE', // 协同处理-协同类型
	I_LT_SITUATION: 'I_LT_SITUATION', // 案件查办-督办情形
	I_FIELD_CHECK_STATE: 'I_FIELD_CHECK_STATE', // 实地核查-核查状态
	I_HANDSIGN_REASON: 'I_HANDSIGN_REASON', // 实地核查-签到方式
	C_PROPERTY_TYPE: 'C_PROPERTY_TYPE', // 案由
	C_REPORT_TYPE: 'C_REPORT_TYPE', // 普通案件-举报类型
	C_TRANS_SOURCE: 'C_TRANS_SOURCE', // 普通案件-移送来源
	M_SIMPLING_RESULT_TYPE: 'M_SIMPLING_RESULT_TYPE', // 考核结果
	Q_REPORT_BACK_CAUSE: 'Q_REPORT_BACK_CAUSE', // 质检报告退回
	L_ORDER_CYCLE_TYPE: 'L_ORDER_CYCLE_TYPE', // 订货周期
	L_DELIVER_PERIOD: 'L_DELIVER_PERIOD', // 送货周期
	L_DELIVER_TYPE: 'L_DELIVER_TYPE', // 送货方式
	L_QR_CARD_STATUS: 'L_QR_CARD_STATUS', // 二维码制卡状态
	L_CHAIN_TYPE: 'L_CHAIN_TYPE', // 连锁经营
	S_DELIVERY_TYPE: 'S_DELIVERY_TYPE', // 电子送达类型
	C_CASE_TYPE: 'C_CASE_TYPE', // 案件类型
	Q_SAMPLE_DESCRIBE: 'Q_SAMPLE_DESCRIBE', // 样品状态
	L_BUSINESS_VALID_TYPE: 'L_BUSINESS_VALID_TYPE', // 营业执照有效期类型
	L_REMINDER_DUE_DAYS: 'L_REMINDER_DUE_DAYS', // 距到期天数
	L_BUSINESS_CONTENT: 'L_BUSINESS_CONTENT', // 经营内容
	L_AREA_TYPE_DETAIL: 'L_AREA_TYPE_DETAIL', // 地缘情况
	T_PERSON_POLITICS:'T_PERSON_POLITICS',//政治面貌

	L_UNLIC_ECIG_ENT_ENT_TYPE: 'L_UNLIC_ECIG_ENT_ENT_TYPE', // 无证电子烟经营企业企业类型
	L_UNLIC_ECIG_ENT_SOURCE: 'L_UNLIC_ECIG_ENT_SOURCE', // 无证电子烟经营企业来源
	L_UNLIC_ECIG_ENT_STATUS: 'L_UNLIC_ECIG_ENT_STATUS', // 无证电子烟经营企业状态
	L_UNLIC_ECIG_ENT_BUSINESS_TYPE: 'L_UNLIC_ECIG_ENT_BUSINESS_TYPE', // 无证电子烟经营企业业务类型
	L_UNLIC_ECIG_ENT_PRODUCT_TYPE: 'L_UNLIC_ECIG_ENT_PRODUCT_TYPE', // 无证电子烟经营企业产品类型
	M_UNLIC_ECIG_ENT_BUSINESS_TYPE: 'M_UNLIC_ECIG_ENT_BUSINESS_TYPE', // 无证生产经营企业类型
	L_UNLIC_ECIG_ENT_MATETIAL_TYPE: 'L_UNLIC_ECIG_ENT_MATETIAL_TYPE', // 无证电子烟经营企业物料类型
	M_UNLIC_ECIG_ENT_CHECK_ITEM: 'M_UNLIC_ECIG_ENT_CHECK_ITEM', // 无证电子烟生产企业检查项

	LOC_VISIT_PUBLICITY_CODE: 'LOC_VISIT_PUBLICITY_CODE', // (辽宁)走访记录-宣传类(	// 辽宁特例 zyf 2023-11-21 start)
	LOC_VISIT_SERVICE_CODE: 'LOC_VISIT_SERVICE_CODE', // (辽宁)走访记录-服务(	// 辽宁特例 zyf 2023-11-21 end)
	I_CUST_TYPE_LEVEL: 'I_CUST_TYPE_LEVEL', // 客户分类

	// 内蒙统计查询 2024-2-18 start
	I_RS_PRODUCT_UINT: 'I_RS_PRODUCT_UINT',
	I_CASE_CYCLE: 'I_CASE_CYCLE',
	I_CASE_DATE_TYPE: 'I_CASE_DATE_TYPE',
	// 内蒙统计查询 2024-2-18 end
	//广西/福建信用修复发起  zx 2024-07-15
	M_REPAIR_TYPE:'M_REPAIR_TYPE',//修复类型
	M_REPAIR_STATUS:'M_REPAIR_STATUS',//修复状态
	M_REPAIR_SOURCE:'M_REPAIR_SOURCE',//申请来源
	M_REPAIR_REVIEW_TYPE:'M_REPAIR_REVIEW_TYPE',//核查情况
	//广西/福建信用修复发起  zx 2024-07-15
}
/**
 * @param {Object} arr  数据字典所有数据
 */
function setDic2Storage(arr) {
	if (arr && arr.length > 0) {
		let map = {};
		for (let i = 0; i < arr.length; i++) {
			delete arr[i].allowModify;
			delete arr[i].applyRange;
			delete arr[i].createTime;
			delete arr[i].isActive;
			delete arr[i].modifyTime;
			arr[i].label = arr[i].bcbName;
			arr[i].value = arr[i].bcbCode;
			if (!map[arr[i].bctPhName]) {
				map[arr[i].bctPhName] = new Array();
			}
			map[arr[i].bctPhName].push(arr[i]);
		}
		store.state.dicts = map;
		// 兼容处理目前的代码，上线后删除
		uni.setStorageSync(DIC_ALL_DATA, JSON.stringify(arr));
		uni.setStorageSync(DIC_DICT_MAP, JSON.stringify(map));
	}
}

const install = (Vue, vm) => {
	// 初始化数据字典调用
	let dicDataInit = () => {
		return new Promise(function(resolve, reject) {
			if (store.state.dicts) {
				resolve();
				return;
			}
			commonService.loadAllDicts().then(
				(res) => {
					if (res.success) {
						// 解析数据 存入localStorage
						setDic2Storage(res.data);
						resolve();
					} else {
						reject('获取失败');
					}
				},
				(err) => {
					reject(err);
				}
			);
		});
	};

	// 获取数据字典的接口
	let getDicByKey = (keys) => {
		return new Promise(function(resolve, reject) {
			if (store.state.dicts) {
				// 表示初始化时存入数据字典成功
				try {
					let map = store.state.dicts;
					let data = map[keys];
					resolve(data);
					return;
				} catch (e) {
					console.log(e);
					reject('解析失败');
					return;
				}
			} else {
				commonService.loadAllDicts().then(
					(res) => {
						if (res.success) {
							// 解析数据 存入localStorage
							setDic2Storage(res.data);
							// 给用户返回数据
							if (store.state.dicts) {
								try {
									let map = store.state.dicts;
									let data = map[keys];
									resolve(data);
									return;
								} catch (e) {
									console.log(e);
									reject('解析失败');
									return;
								}
							}
						} else {
							reject('获取失败');
						}
					},
					(err) => {
						reject(err);
					}
				);
			}
		});
	};
	let getDicNameByKeyCode = function(KeyWords, code) {
		if (store.state.dicts) {
			// 表示初始化时存入数据字典成功
			try {
				let map = store.state.dicts;
				let data = map[KeyWords];
				if (data) {
					for (let i = 0; i < data.length; i++) {
						if (code == data[i].bcbCode) {
							return data[i].bcbName;
						}
					}
				}
			} catch (e) {
				console.log(e);
			}
		}
		return '';
	};
	let getDicCodeByName = function(KeyWords, name) {
		if (store.state.dicts) {
			// 表示初始化时存入数据字典成功
			try {
				let map = store.state.dicts;
				let data = map[KeyWords];
				if (data) {
					for (let i = 0; i < data.length; i++) {
						if (name == data[i].bcbName) {
							return data[i].bcbCode;
						}
					}
				}
			} catch (e) {
				console.log(e);
			}
		}
		return '';
	};

	let getDicByKeyCode = function(KeyWords, isAnsy = false) {
		if (!isAnsy) {
			if (store.state.dicts) {
				// 表示初始化时存入数据字典成功
				try {
					let map = store.state.dicts;
					let data = map[KeyWords];
					return data;
				} catch (e) {
					console.log(e);
				}
			}
			return [];
		} else {
			return new Promise((resolve) => {
				if (store.state.dicts) {
					// 表示初始化时存入数据字典成功
					try {
						let map = store.state.dicts;
						let data = map[KeyWords];
						resolve(data)
					} catch (e) {
						console.log(e);
						resolve([])
					}
				} else {
					commonService.getBscCodes(KeyWords).then(res => {
						resolve(res.data);
					});
				}
			});
		}
	};
	// 获取数据字典的接口
	let getDicNameByDDextCode = (DdExtCode, KeyWords) => {
		return new Promise(function(resolve, reject) {
			if (DdExtCode == null || DdExtCode == '' || DdExtCode == undefined) {
				reject('请求参数不能为空');
				return;
			}
			if (store.state.dicts) {
				// 表示初始化时存入数据字典成功
				try {
					let map = store.state.dicts;
					let data = map[KeyWords];
					if (data) {
						for (let i = 0; i < data.length; i++) {
							if (DdExtCode == data[i].bcbCode) {
								resolve(data[i]);
								return;
							}
						}
					}
				} catch (e) {
					reject('解析失败');
					return;
				}
				reject('无数据匹配');
			} else {
				commonService.loadAllDicts().then(
					(res) => {
						if (res.success) {
							// 解析数据 存入localStorage
							setDic2Storage(res.data);
							// 给用户返回数据
							if (store.state.dicts) {
								try {
									let map = store.state.dicts;
									let data = map[KeyWords];
									if (data) {
										for (let i = 0; i < data.length; i++) {
											if (DdExtCode == data[i].bcbCode) {
												resolve(data[i]);
												return;
											}
										}
									}
								} catch (e) {
									reject('解析失败');
									return;
								}
							}
						} else {
							reject('获取失败');
						}
					},
					(err) => {
						reject(err);
					}
				);
			}
		});
	};

	// 获取多个code array 的names
	let getDicNamesByDDextCodes = (DdExtCode, KeyWords) => {
		if ((typeof DdExtCode) == 'number') {
			DdExtCode = DdExtCode.toFixed(0);
		}
		return new Promise(function(resolve, reject) {
			if (DdExtCode == null || DdExtCode == '' || DdExtCode == undefined) {
				reject('请求参数不能为空');
				return;
			}
			if (store.state.dicts) {
				// 表示初始化时存入数据字典成功
				try {
					let map = store.state.dicts;
					let data = map[KeyWords];
					if (data) {
						let names = [];
						let codes = DdExtCode.split(',');
						for (let i = 0; i < data.length; i++) {
							if (codes.includes(data[i].bcbCode)) {
								names.push(data[i].bcbName);
							}
						}
						resolve(names.join(','));
						return;
					}
				} catch (e) {
					reject('解析失败');
					return;
				}
				reject('无数据匹配');
			} else {
				commonService.loadAllDicts().then(
					(res) => {
						if (res.success) {
							// 解析数据 存入localStorage
							setDic2Storage(res.data);
							// 给用户返回数据
							if (store.state.dicts) {
								try {
									let map = store.state.dicts;
									let data = map[KeyWords];
									if (data) {
										let names = [];
										let codes = DdExtCode.split(',');
										for (let i = 0; i < data.length; i++) {
											if (codes.includes(data[i].bcbCode)) {
												names.push(data[i].bcbName);
											}
										}
										resolve(names.join(','));
										return;
									}
								} catch (e) {
									reject('解析失败');
									return;
								}
							}
						} else {
							reject('获取失败');
						}
					},
					(err) => {
						reject(err);
					}
				);
			}
		});
	};
	// 获取数据字典的接口
	let getByDictCode = (dictCode) => {
		if (dictCode == null || dictCode == '' || dictCode == undefined) {
			console.error('请求参数不能为空');
			return [];
		}
		if (store.state.dicts) {
			// 表示初始化时存入数据字典成功
			try {
				let map = store.state.dicts;
				let data = map[dictCode];
				return data;
			} catch (e) {
				console.error(e);
				return [];
			}
		} else {
			commonService.loadAllDicts().then(
				(res) => {
					if (res.success) {
						// 解析数据 存入sessionStorage
						setDic2Storage(res.data);
						// 给用户返回数据
						if (store.state.dicts) {
							try {
								console.log("查询缓存的字典信息", store.state.dicts);
								let map = store.state.dicts;
								let data = map[dictCode];
								return data;
							} catch (e) {
								console.error(e);
								return [];
							}
						}
					} else {
						return [];
					}
				},
				(err) => {
					return [];
				}
			);
		}
	};

	// 从指定字典中获取对应编码中文描述
	let getDictName = (bctPhName, dictCode) => {
		if (!bctPhName) return ''
		if (!dictCode) return ''
		return store.state.dicts[bctPhName].filter(d => d.bcbCode === dictCode)[0].bcbName;
	}
	// 获取数据字典的接口
	let getDictNameByCode = (dictCodes, isAsync = false) => {
		if (isAsync) {
			if (dictCodes == null || dictCodes == '' || dictCodes == undefined) {
				return '';
			}
			if (!store.state.dicts) return '';
			try {
				let allData = store.state.dicts;
				let codes = dictCodes.split(',');
				let result = new Array();
				for (let i = 0; i < codes.length; i++) {
					for (let j = 0; j < allData.length; j++) {
						if (codes[i] == allData[j].bcbCode) {
							result.push(allData[j].bcbName);
							break;
						}
					}
				}
				if (result.length > 0) {
					return result.join(',');
				}
			} catch (e) {
				return '';
			}
			return '';
		}
		return new Promise(function(resolve, reject) {
			if (dictCodes == null || dictCodes == '' || dictCodes == undefined) {
				reject('请求参数不能为空');
				return;
			}
			if (store.state.dicts) {
				// 表示初始化时存入数据字典成功
				try {
					let allData = store.state.dicts;
					let codes = dictCodes.split(',');
					let result = new Array();
					for (let i = 0; i < codes.length; i++) {
						for (let j = 0; j < allData.length; j++) {
							if (codes[i] == allData[j].bcbCode) {
								result.push(allData[j].bcbName);
								break;
							}
						}
					}
					if (result.length > 0) {
						resolve(result.join(','));
						return;
					}
				} catch (e) {
					reject('解析失败');
					return;
				}
				reject('无数据匹配');
			} else {
				commonService.loadAllDicts().then(
					(res) => {
						if (res.success) {
							// 解析数据 存入sessionStorage
							setDic2Storage(res.data);
							// 给用户返回数据
							if (store.state.dicts) {
								try {
									let allData = store.state.dicts;
									let codes = dictCodes.split(',');
									let result = new Array();
									for (let i = 0; i < codes.length; i++) {
										for (let j = 0; j < allData.length; j++) {
											if (codes[i] == allData[j].bcbCode) {
												result.push(allData[j].bcbName);
												break;
											}
										}
									}
									if (result.length > 0) {
										resolve(result.join(','));
										return;
									}
									return;
								} catch (e) {
									reject('解析失败');
									return;
								}
							}
						} else {
							reject('获取失败');
						}
					},
					(err) => {
						reject(err);
					}
				);
			}
		});
	};

	// 将各个定义的接口名称，统一放进对象挂载到vm.$u.api(因为vm就是this，也即this.$u.api)下
	vm.$u.dic = {
		DIC_KEYS,
		dicDataInit,
		getDicByKey,
		getDicByKeyCode,
		getDicCodeByName, // 根据name 反查code
		getDicNameByDDextCode, // 根据dextCode 获取字典对象 ,
		getDicNamesByDDextCodes, // 应对多选字典，根据多选的codes 获取names
		getDicNameByKeyCode, // 同步方法获取dic的 显示名称
		getByDictCode, // 根据key获取字典数据
		getDictName,
		getDictNameByCode,
	};
};

export default {
	install,
};
